package com.gw.business.common.util.excel;

import java.io.IOException;
import java.io.InputStream;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import com.gw.platform.util.StringUtils;



/**
 * Excel解析
 * 
 * @project: support
 * @Date:2010-11-10
 * @version 1.0
 * @Company: 33e9
 * @author hui.long
 */
public class ExcelParseScript {

	private static final String XLS = "xls";

	/**
	 * 数据模型
	 */
	protected Object[] objs;

	/**
	 * 需要读取的excel中sheet下标值
	 */
	private int sheetIndex;

	/**
	 * 解析excel工作表对象
	 */
	private Workbook wb;

	/**
	 * 工作表
	 */
	private Sheet sheet;

	/**
	 * 行对象
	 */
	private Row row;

	/**
	 * 单元格对象
	 */
	@SuppressWarnings("unused")
	private Cell cell;

	private static DecimalFormat df = new DecimalFormat("#.#");

	public void setSheetIndex(int sheetIndex) {
		this.sheetIndex = sheetIndex;
	}

	public void builExcel(InputStream inputStream, String fileType)
			throws IOException {
		if (XLS.equals(fileType)) {
			wb = new HSSFWorkbook(inputStream);
		} else {
			try{
				wb = new XSSFWorkbook(inputStream);
			}catch(Exception e){
				wb = new HSSFWorkbook(inputStream);
			}
		}
	}

	/**
	 * 查询单个工作薄
	 * 
	 * @param startRow
	 * @param startCell
	 */
	public ArrayList<Object[]> getSheetCellValue(int startRow, int startCell) {
		ArrayList<Object[]> resultList = new ArrayList<Object[]>();
		sheet = wb.getSheetAt(sheetIndex);
		String value = "";
		// 获取总行数
		int rowIndex = sheet.getPhysicalNumberOfRows();
		// 获取第一行的总列数
		int cellIndex = sheet.getRow(startRow).getPhysicalNumberOfCells();
		// 开始行数自增1，从第二行开始读数据，第一行为标题
		startRow = startRow + 1;
		for (int i = startRow; i < rowIndex; i++) {
			// 获取单元格
			row = sheet.getRow(i);

			if (null != row) {
				objs = new Object[cellIndex];
				
				//整行记录是否为空标识
				boolean isExist = true;
				
				for (int j = startCell; j < cellIndex; j++) {
					value = getCellValue(row, j);
					objs[j] = value.trim();
					if (isExist) {
						isExist = StringUtils.isEmpty(value);
						
					}
				}
				// 整行记录中所有单元格为空,该空行不获取
				if (!isExist) {
					resultList.add(objs);
				}
				objs = null;
			} else {
				rowIndex++;
			}

		}
		return resultList;
	}

	/**
	 * 查询多个工作薄中的值，并返回
	 * 
	 * @param startRow
	 * @param startCell
	 */
	public ArrayList<ArrayList<Object[]>> getMuiltSheetCellValue(
			Integer[] startRow, Integer[] startCell) {

		boolean flag = false;

		// 保存表集合
		ArrayList<ArrayList<Object[]>> tables = new ArrayList<ArrayList<Object[]>>();

		// 保存行集合
		ArrayList<Object[]> rows = null;

		// 单元格中的值
		String value = "";

		// 行中有值的单元格总数量
		int cellTotalNum = 0;

		// 获以多个工作薄
		for (int numSheet = 0; numSheet < wb.getNumberOfSheets(); numSheet++) {

			rows = new ArrayList<Object[]>();

			// 获取其中一个工作薄
			sheet = wb.getSheetAt(numSheet);

			// 读取单个工作薄中的行
			for (int numRow = startRow[numSheet]; numRow <= sheet
					.getLastRowNum(); numRow++) {

				row = sheet.getRow(numRow);
				if (null != row) {
					cellTotalNum = row.getLastCellNum();
					objs = new Object[cellTotalNum];

					// 读取行中单元格的值
					// if(null != row.getCell(startCell[numSheet])){
					for (int numCell = startCell[numSheet]; numCell <= cellTotalNum; numCell++) {
						value = getCellValue(row, numCell);
						if (null != value && !"".equals(value)) {
							objs[numCell] = value;
							flag = true;
						}
					}
					if (flag) {
						rows.add(objs);
					}
					objs = null;
					flag = false;
					// }
				}
			}
			if (rows.size() > 0)
				tables.add(rows);
			rows = null;
		}
		return tables;
	}

	/**
	 * 获取获取单元格值
	 * 
	 * @param row
	 *            excel行对象
	 * @param index
	 *            excel单元格的位置
	 * @return 返回获取单元格值
	 */
	protected static String getCellValue(Row row, int index) {
		return getCellValue(row, index, Integer.MAX_VALUE);
	}

	/**
	 * 获取获取单元格值
	 * 
	 * @param row
	 *            excel行对象
	 * @param index
	 *            excel单元格的位置
	 * @param maxLength单元格值最大长度
	 * @return 返回获取单元格值
	 */
	protected static String getCellValue(Row row, int index, int maxLength) {
		return getCellValue(row.getCell((short) index), maxLength);
	}

	/**
	 * 获取获取单元格值，如果为空就返回0
	 * 
	 * @param row
	 *            excel行对象
	 * @param index
	 *            excel单元格的位置
	 * @param maxLength单元格值最大长度
	 * @return 返回获取单元格值
	 */
	protected static String getCellValueReturnZero(Row row, int index,
			int maxLength) {
		String value = getCellValue(row.getCell((short) index), maxLength);
		return "".equals(value) ? "0" : value;
	}

	/**
	 * 获取获取单元格值
	 * 
	 * @param cell
	 *            单元格对象
	 * @param maxLength
	 *            单元格值最大长度
	 * @return
	 */
	protected static String getCellValue(Cell cell, int maxLength) {
		String value = "";
		if (cell != null) {
			switch (cell.getCellType()) {
			case Cell.CELL_TYPE_STRING:
				value = cell.getStringCellValue();
				break;
			case Cell.CELL_TYPE_NUMERIC:
				if (DateUtil.isCellDateFormatted(cell)) {
					DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
					value = sdf.format(cell.getDateCellValue());
				} else {
					value = df.format(cell.getNumericCellValue());
				}
				break;
			case Cell.CELL_TYPE_BOOLEAN:
				value = String.valueOf(cell.getBooleanCellValue());
				break;
			}
		}
		value = value.trim();
		return value.substring(0, maxLength > value.length() ? value.length()
				: maxLength);
	}
}
